/**
 * 闹钟后台服务
 * 用于处理闹钟的周期切换和提醒
 */
import { loadAlarmList, saveAlarmList, switchToNextCycle, checkTodayAlarm } from './alarm-utils.js';
import { alarmAdd } from "@/uni_modules/laoqianjunzi-alarm";

// 后台服务状态
let isServiceRunning = false;
let checkInterval = null;

// 启动后台服务
export function startAlarmService() {
    if (isServiceRunning) return;
    
    console.log('启动闹钟后台服务');
    isServiceRunning = true;
    
    // 每15分钟检查一次闹钟，确保自定义周期闹钟能够正确触发
    checkInterval = setInterval(() => {
        checkAndUpdateAlarms();
    }, 15 * 60 * 1000); // 每15分钟检查一次
    
    // 立即执行一次检查
    checkAndUpdateAlarms();
}

// 停止后台服务
export function stopAlarmService() {
    if (!isServiceRunning) return;
    
    console.log('停止闹钟后台服务');
    isServiceRunning = false;
    
    if (checkInterval) {
        clearInterval(checkInterval);
        checkInterval = null;
    }
}

// 检查并更新闹钟
function checkAndUpdateAlarms() {
    console.log('检查闹钟...');
    
    try {
        // 获取所有闹钟
        const alarmList = loadAlarmList();
        console.log('所有闹钟:', alarmList.length);
        
        // 获取今天的星期
        const today = new Date();
        const dayOfWeek = today.getDay(); // 0是周日，1-6是周一到周六
        const weekdayMap = {
            0: '7', // 周日
            1: '1', // 周一
            2: '2', // 周二
            3: '3', // 周三
            4: '4', // 周四
            5: '5', // 周五
            6: '6'  // 周六
        };
        const todayWeekday = weekdayMap[dayOfWeek];
        console.log('今天是:', todayWeekday);
        
        // 过滤出今天需要响铃的闹钟
        const todayAlarms = alarmList.filter(alarm => {
            if (!alarm.enabled) return false;
            
            if (alarm.customCycle) {
                // 如果是自定义周期，检查当前周期是否包含今天
                const currentCycle = alarm.cycles[alarm.currentCycleIndex];
                return currentCycle.includes(todayWeekday);
            } else {
                // 如果是普通重复，直接检查是否包含今天
                return alarm.weekday.includes(todayWeekday);
            }
        });
        
        console.log('今天的闹钟:', todayAlarms.length);
        
        // 处理每个闹钟
        todayAlarms.forEach(alarm => {
            // 如果是自定义周期闹钟，设置定时器在闹钟触发后切换到下一个周期
            if (alarm.customCycle && alarm.enabled) {
                scheduleNextCycleSwitch(alarm);
            }
            
            // 如果闹钟已启用，确保系统闹钟已设置
            if (alarm.enabled) {
                setSystemAlarm(alarm);
            }
        });
        
        // 检查是否有需要预先设置的闹钟（明天的闹钟）
        const tomorrow = new Date();
        tomorrow.setDate(tomorrow.getDate() + 1);
        const tomorrowDayOfWeek = tomorrow.getDay();
        const tomorrowWeekday = weekdayMap[tomorrowDayOfWeek];
        
        console.log('明天是:', tomorrowWeekday);
        
        // 过滤出明天需要响铃的闹钟
        const tomorrowAlarms = alarmList.filter(alarm => {
            if (!alarm.enabled) return false;
            
            if (alarm.customCycle) {
                // 如果是自定义周期，检查当前周期是否包含明天
                const currentCycle = alarm.cycles[alarm.currentCycleIndex];
                return currentCycle.includes(tomorrowWeekday);
            } else {
                // 如果是普通重复，直接检查是否包含明天
                return alarm.weekday.includes(tomorrowWeekday);
            }
        });
        
        console.log('明天的闹钟:', tomorrowAlarms.length);
        
        // 如果今天没有闹钟但明天有，预先设置明天的闹钟
        if (todayAlarms.length === 0 && tomorrowAlarms.length > 0) {
            console.log('预先设置明天的闹钟');
            tomorrowAlarms.forEach(alarm => {
                if (alarm.enabled) {
                    // 对于自定义周期闹钟，我们需要特殊处理
                    if (alarm.customCycle) {
                        // 设置明天的闹钟，但不切换周期
                        const params = {
                            name: alarm.name + " (明天)",
                            weekday: "",  // 不设置重复
                            hour: alarm.hour,
                            minutes: alarm.minutes,
                            ringtone: alarm.ringtone || 'https://jubaomusics.oss-cn-beijing.aliyuncs.com/%E4%B8%89%E5%8F%AA%E5%B0%8F%E7%8C%AA/%E4%B8%89%E5%8F%AA%E5%B0%8F%E7%8C%AA.mp3'
                        };
                        
                        alarmAdd({
                            params: params,
                            success: (res) => {
                                console.log('明天的自定义周期闹钟设置成功', res);
                            },
                            fail: (res) => {
                                console.log('明天的自定义周期闹钟设置失败', res);
                            },
                            complete: () => {
                                console.log('明天的自定义周期闹钟设置完成');
                            },
                        });
                    } else {
                        // 普通闹钟，直接设置
                        setSystemAlarm(alarm);
                    }
                }
            });
        }
    } catch (e) {
        console.error('检查闹钟失败', e);
    }
}

// 设置系统闹钟
function setSystemAlarm(alarm) {
    // 如果是自定义周期，我们需要特殊处理
    if (alarm.customCycle) {
        // 获取当前周期的weekday
        const currentCycleWeekday = alarm.cycles[alarm.currentCycleIndex];
        
        // 为当前周期创建一个普通闹钟（不设置重复）
        // 这样系统闹钟响铃后，我们的应用会负责切换到下一个周期
        const params = {
            name: alarm.name + " (周期" + (alarm.currentCycleIndex + 1) + ")",
            // 不设置重复，让系统闹钟只响一次
            weekday: "",
            hour: alarm.hour,
            minutes: alarm.minutes,
            ringtone: alarm.ringtone || 'https://jubaomusics.oss-cn-beijing.aliyuncs.com/%E4%B8%89%E5%8F%AA%E5%B0%8F%E7%8C%AA/%E4%B8%89%E5%8F%AA%E5%B0%8F%E7%8C%AA.mp3'
        };
        
        console.log('设置自定义周期闹钟', params);
        
        alarmAdd({
            params: params,
            success: (res) => {
                console.log('自定义周期闹钟设置成功', res);
            },
            fail: (res) => {
                console.log('自定义周期闹钟设置失败', res);
            },
            complete: () => {
                console.log('自定义周期闹钟设置完成');
            },
        });
    } else {
        // 普通闹钟，直接使用系统闹钟的重复功能
        const params = {
            name: alarm.name,
            weekday: alarm.weekday,
            hour: alarm.hour,
            minutes: alarm.minutes,
            ringtone: alarm.ringtone || 'https://jubaomusics.oss-cn-beijing.aliyuncs.com/%E4%B8%89%E5%8F%AA%E5%B0%8F%E7%8C%AA/%E4%B8%89%E5%8F%AA%E5%B0%8F%E7%8C%AA.mp3'
        };
        
        alarmAdd({
            params: params,
            success: (res) => {
                console.log('普通闹钟设置成功', res);
            },
            fail: (res) => {
                console.log('普通闹钟设置失败', res);
            },
            complete: () => {
                console.log('普通闹钟设置完成');
            },
        });
    }
}

// 安排下一个周期切换
function scheduleNextCycleSwitch(alarm) {
    // 计算下一次闹钟触发的时间
    const now = new Date();
    const alarmTime = new Date();
    alarmTime.setHours(alarm.hour);
    alarmTime.setMinutes(alarm.minutes);
    alarmTime.setSeconds(0);
    
    // 如果闹钟时间已过，设置为明天
    if (alarmTime <= now) {
        alarmTime.setDate(alarmTime.getDate() + 1);
    }
    
    // 计算时间差（毫秒）
    const timeDiff = alarmTime.getTime() - now.getTime();
    console.log(`闹钟 ${alarm.name} 将在 ${timeDiff/1000/60} 分钟后触发，然后切换周期`);
    
    // 设置定时器，在闹钟触发后切换周期
    setTimeout(() => {
        console.log(`闹钟 ${alarm.name} 触发，切换到下一个周期`);
        
        // 切换到下一个周期
        const updatedAlarm = switchToNextCycle(alarm);
        
        // 如果成功切换周期并且闹钟启用，重新设置系统闹钟
        if (updatedAlarm && updatedAlarm.enabled) {
            // 获取下一个周期的日期
            const nextCycleWeekday = updatedAlarm.cycles[updatedAlarm.currentCycleIndex];
            const today = new Date();
            const dayOfWeek = today.getDay(); // 0是周日，1-6是周一到周六
            const weekdayMap = {
                0: '7', // 周日
                1: '1', // 周一
                2: '2', // 周二
                3: '3', // 周三
                4: '4', // 周四
                5: '5', // 周五
                6: '6'  // 周六
            };
            const todayWeekday = weekdayMap[dayOfWeek];
            
            // 检查下一个周期是否包含今天的星期
            // 如果包含，则立即设置闹钟
            // 如果不包含，则等待下一次检查
            if (nextCycleWeekday.includes(todayWeekday)) {
                console.log(`下一个周期包含今天(${todayWeekday})，立即设置闹钟`);
                setSystemAlarm(updatedAlarm);
            } else {
                console.log(`下一个周期不包含今天(${todayWeekday})，等待下一次检查`);
                // 下次检查时会自动设置
            }
        }
    }, timeDiff + 1000); // 加1秒确保闹钟已触发
}